// All of the Node.js APIs are available in the preload process.
// It has the same sandbox as a Chrome extension.
const { contextBridge, ipcRenderer, shell } = require('electron');

console.log('预加载脚本开始执行');

// 暴露基本API给渲染进程
contextBridge.exposeInMainWorld('electronAPI', {
  clearCache: () => {
    console.log('调用clearCache');
    return ipcRenderer.invoke('clear-cache');
  },
  // 调用主进程的完整缓存清理功能
  callMainClearCache: () => {
    console.log('调用主进程完整的缓存清理功能');
    return ipcRenderer.invoke('call-main-clear-cache');
  },
  // 新接口：调用菜单项中的缓存清理功能（直接触发主进程的clearCache函数）
  menuClearCache: () => {
    console.log('调用菜单项中的缓存清理');
    return ipcRenderer.invoke('menu-clear-cache');
  },
  // 新增: 检查更新
  checkForUpdates: () => {
    console.log('调用检查更新');
    return ipcRenderer.invoke('check-for-updates');
  },
  // 新增: 下载更新
  downloadUpdate: (url) => {
    console.log('调用下载更新:', url);
    return ipcRenderer.invoke('download-update', url);
  },
  // 新增: 安装更新
  installUpdate: (path) => {
    console.log('调用安装更新:', path);
    return ipcRenderer.invoke('install-update', path);
  },
  // 新增: 重启应用
  restartApp: () => {
    console.log('调用重启应用');
    return ipcRenderer.invoke('restart-app');
  },
  // 新增: 监听更新事件
  onUpdateAvailable: (callback) => {
    ipcRenderer.on('update-available', (event, updateInfo) => {
      console.log('收到update-available事件:', updateInfo);
      callback(updateInfo);
    });
  },
  // 新增: 监听强制更新事件
  onUpdateForceAvailable: (callback) => {
    ipcRenderer.on('update-force-available', (event, updateInfo) => {
      console.log('收到update-force-available事件:', updateInfo);
      callback(updateInfo);
    });
  },
  // 新增: 监听正在检查更新事件
  onUpdateChecking: (callback) => {
    ipcRenderer.on('update-checking', () => {
      console.log('收到update-checking事件');
      callback();
    });
  },
  // 新增: 监听没有可用更新事件
  onUpdateNotAvailable: (callback) => {
    ipcRenderer.on('update-not-available', () => {
      console.log('收到update-not-available事件');
      callback();
    });
  },
  // 新增: 监听更新检查错误事件
  onUpdateError: (callback) => {
    ipcRenderer.on('update-error', (event, errorData) => {
      console.log('收到update-error事件:', errorData);
      callback(errorData);
    });
  },
  // 新增: 监听开始下载更新事件
  onUpdateDownloadStart: (callback) => {
    ipcRenderer.on('update-download-start', (event, updateInfo) => {
      console.log('收到update-download-start事件:', updateInfo);
      callback(updateInfo);
    });
  },
  // 新增: 监听下载进度事件
  onUpdateDownloadProgress: (callback) => {
    ipcRenderer.on('update-download-progress', (event, progress) => {
      console.log('收到update-download-progress事件:', progress);
      callback(progress);
    });
  },
  // 新增: 监听下载完成事件
  onUpdateDownloadCompleted: (callback) => {
    ipcRenderer.on('update-download-completed', () => {
      console.log('收到update-download-completed事件');
      callback();
    });
  },
  // 新增: 监听下载错误事件
  onUpdateDownloadError: (callback) => {
    ipcRenderer.on('update-download-error', (event, errorData) => {
      console.log('收到update-download-error事件:', errorData);
      callback(errorData);
    });
  },
  // 新增: 获取当前版本
  getAppVersion: () => {
    return ipcRenderer.invoke('get-app-version');
  },
  minimizeWindow: () => {
    console.log('调用minimizeWindow');
    ipcRenderer.send('minimize-window');
  },
  maximizeWindow: () => {
    console.log('调用maximizeWindow');
    ipcRenderer.send('maximize-window');
  },
  closeWindow: () => {
    console.log('调用closeWindow');
    ipcRenderer.send('close-window');
  },
  onReloadWebview: (callback) => {
    console.log('设置onReloadWebview监听器');
    ipcRenderer.on('reload-webview', () => {
      console.log('接收到reload-webview消息');
      callback();
    });
  },
  // 添加用于创建新标签的API
  createNewTab: (callback) => {
    console.log('设置createNewTab监听器');
    ipcRenderer.on('create-new-tab', (event, url) => {
      console.log('接收到create-new-tab消息:', url);
      callback(url);
    });
  },
  // 发送创建新标签请求
  sendCreateNewTab: (url) => {
    console.log('发送createNewTab请求:', url);
    ipcRenderer.send('create-new-tab', url);
  },
  // 添加用于打开外部链接的API
  openExternal: (url) => {
    console.log('调用openExternal:', url);
    if (url && typeof url === 'string' && (url.startsWith('http://') || url.startsWith('https://'))) {
      ipcRenderer.send('open-external', url);
    } else {
      console.warn('无效的外部链接:', url);
    }
  },
  // 获取当前操作系统主题
  getSystemTheme: () => {
    if (window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches) {
      return 'dark';
    } else {
      return 'light';
    }
  },
  // 监听系统主题变化
  onSystemThemeChange: (callback) => {
    if (window.matchMedia) {
      const darkModeMediaQuery = window.matchMedia('(prefers-color-scheme: dark)');
      const listener = (e) => {
        const newTheme = e.matches ? 'dark' : 'light';
        callback(newTheme);
      };
      
      // 添加监听器
      if (darkModeMediaQuery.addEventListener) {
        darkModeMediaQuery.addEventListener('change', listener);
      } else if (darkModeMediaQuery.addListener) {
        // 旧版API兼容
        darkModeMediaQuery.addListener(listener);
      }
    }
  },
  // 切换窗口显示/隐藏状态
  toggleWindowVisibility: () => {
    console.log('调用toggleWindowVisibility');
    ipcRenderer.send('toggle-window-visibility');
  },
  // 获取当前注册的快捷键
  getRegisteredHotkey: () => {
    console.log('获取已注册的快捷键');
    return ipcRenderer.invoke('get-registered-hotkey');
  },
  // 新增: 用户确认更新
  confirmUpdate: () => {
    console.log('用户确认更新');
    return ipcRenderer.invoke('confirm-update');
  },
  // 新增: 用户选择稍后更新
  postponeUpdate: () => {
    console.log('用户选择稍后更新');
    return ipcRenderer.invoke('postpone-update');
  },
  // 新增: 处理自定义对话框
  onShowCustomDialog: (callback) => {
    ipcRenderer.on('show-custom-dialog', (event, options) => {
      console.log('收到show-custom-dialog事件:', options);
      callback(options);
    });
  },
  // 新增: 发送对话框响应
  sendDialogResponse: (id, response) => {
    console.log('发送对话框响应:', id, response);
    return ipcRenderer.invoke('dialog-response', { id, response });
  },
  // 新增: 监听缓存清理开始事件
  onCacheClearingStart: (callback) => {
    ipcRenderer.on('cache-clearing-start', () => {
      console.log('收到cache-clearing-start事件');
      callback();
    });
  },
  // 新增: 监听缓存清理成功事件
  onCacheClearingSuccess: (callback) => {
    ipcRenderer.on('cache-clearing-success', () => {
      console.log('收到cache-clearing-success事件');
      callback();
    });
  },
  // 新增: 监听缓存清理错误事件
  onCacheClearingError: (callback) => {
    ipcRenderer.on('cache-clearing-error', (event, errorData) => {
      console.log('收到cache-clearing-error事件:', errorData);
      callback(errorData);
    });
  }
});

// Electron通信桥接器 (供webview中的脚本使用)
contextBridge.exposeInMainWorld('electron', {
  createNewTab: (url) => {
    console.log('webview调用createNewTab:', url);
    ipcRenderer.send('create-new-tab', url);
    // 还需要通知渲染进程
    window.postMessage({ type: 'createNewTab', url: url }, '*');
  },
  // 添加打开外部链接的方法
  openExternal: (url) => {
    console.log('webview调用openExternal:', url);
    if (url && typeof url === 'string' && (url.startsWith('http://') || url.startsWith('https://'))) {
      ipcRenderer.send('open-external', url);
    }
  },
  // 获取应用主题设置
  getAppTheme: () => {
    // 从DOM上获取当前设置的主题
    const theme = document.documentElement.getAttribute('data-app-theme') || 'default';
    return theme;
  },
  // 订阅主题变化
  onThemeChange: (callback) => {
    // 监听来自应用的主题变化事件
    document.addEventListener('app-theme-changed', (event) => {
      if (event.detail && event.detail.theme) {
        callback(event.detail.theme);
      }
    });
  }
});

// 监听主进程发来的刷新iframe消息 (兼容旧代码)
ipcRenderer.on('reload-iframe', () => {
  console.log('收到reload-iframe消息');
  const iframe = document.getElementById('main-frame');
  if (iframe) {
    iframe.src = iframe.src;
  }
});

// 设置从webview到主进程的IPC通信
ipcRenderer.on('webview-message', (event, data) => {
  console.log('收到webview消息:', data);
  if (data && data.type === 'createNewTab' && data.url) {
    // 从webview接收创建新标签的请求
    console.log('通过IPC从webview接收到创建新标签请求:', data.url);
    window.postMessage({ type: 'createNewTab', url: data.url }, '*');
  } else if (data && data.type === 'openExternal' && data.url) {
    // 从webview接收打开外部链接的请求
    console.log('通过IPC从webview接收到打开外部链接请求:', data.url);
    if (data.url && typeof data.url === 'string' && (data.url.startsWith('http://') || data.url.startsWith('https://'))) {
      ipcRenderer.send('open-external', data.url);
    }
  }
});

window.addEventListener('DOMContentLoaded', () => {
  console.log('DOM完全加载完成');
  setupLinkInterceptor();
});

console.log('预加载脚本执行完毕');

// 主要的链接拦截功能
function setupLinkInterceptor() {
  try {
    // 重写window.open以拦截新窗口创建
    const originalWindowOpen = window.open;
    window.open = function(url, target, features) {
      console.log('[Preload] 拦截window.open:', url);
      if (url) {
        if (isInternalLink(url)) {
          // 内部链接通过IPC通知并在当前页面打开
          if (ipcRenderer) {
            ipcRenderer.send('create-new-tab', url);
          }
          window.postMessage({ type: 'createNewTab', url: url }, '*');
        } else {
          // 外部链接使用默认浏览器打开
          if (ipcRenderer) {
            ipcRenderer.send('open-external', url);
          }
        }
        return null; // 阻止打开新窗口
      }
      
      // 让原始的window.open处理非URL打开请求
      return originalWindowOpen.apply(this, arguments);
    };
    
    // 添加全局点击事件监听器
    document.addEventListener('click', function(e) {
      const link = e.target.closest('a');
      if (!link) return;
      
      // 拦截以下情况的链接点击：
      // 1. target="_blank"或"_new"的链接
      // 2. 带有rel="noopener"或"noreferrer"的链接
      // 3. 按下Ctrl/Meta键的点击（通常用于在新标签中打开）
      // 4. 中键点击（通常用于在新标签中打开）
      if (link.target === '_blank' || 
          link.target === '_new' || 
          link.getAttribute('rel') === 'noopener' || 
          link.getAttribute('rel') === 'noreferrer' ||
          e.ctrlKey || 
          e.metaKey || 
          e.which === 2) {
        
        const href = link.getAttribute('href');
        if (!href) return;
        
        console.log('[Preload] 拦截链接点击:', href);
        e.preventDefault();
        e.stopPropagation();
        
        if (isInternalLink(href)) {
          // 通知内部链接
          notifyCreateNewTab(href);
        } else {
          // 外部链接使用默认浏览器打开
          openExternalLink(href);
        }
        
        return false;
      }
    }, true); // 使用捕获阶段确保我们先于其他处理程序捕获事件
    
    // 设置消息监听器以接收来自iframe等的消息
    window.addEventListener('message', function(event) {
      const data = event.data;
      if (data && data.type === 'createNewTab' && data.url) {
        console.log('[Preload] 收到创建新标签的消息:', data.url);
        if (isInternalLink(data.url)) {
          notifyCreateNewTab(data.url);
        } else {
          openExternalLink(data.url);
        }
      } else if (data && data.type === 'openExternal' && data.url) {
        console.log('[Preload] 收到打开外部链接的消息:', data.url);
        openExternalLink(data.url);
      }
    });
    
    // 捕获并处理所有iframe
    processFrames();
    
    // 创建一个观察器以处理动态添加的iframe
    const observer = new MutationObserver(function(mutations) {
      for (const mutation of mutations) {
        if (mutation.addedNodes) {
          for (const node of mutation.addedNodes) {
            if (node.tagName === 'IFRAME') {
              setupIframeInterceptor(node);
            } else if (node.querySelectorAll) {
              const iframes = node.querySelectorAll('iframe');
              for (const iframe of iframes) {
                setupIframeInterceptor(iframe);
              }
            }
          }
        }
      }
    });
    
    // 开始观察DOM变化
    observer.observe(document.documentElement, {
      childList: true,
      subtree: true
    });
    
    console.log('[Preload] 链接拦截设置完成');
  } catch (err) {
    console.error('[Preload] 设置链接拦截时出错:', err);
  }
}

// 处理网页中的所有iframe
function processFrames() {
  try {
    const iframes = document.querySelectorAll('iframe');
    for (const iframe of iframes) {
      setupIframeInterceptor(iframe);
    }
  } catch (err) {
    console.error('[Preload] 处理iframe时出错:', err);
  }
}

// 为iframe设置拦截器
function setupIframeInterceptor(iframe) {
  try {
    iframe.onload = function() {
      try {
        // 安全地访问iframe内容
        const iframeWindow = iframe.contentWindow;
        if (!iframeWindow) return;
        
        try {
          // 尝试重写iframe的window.open
          const originalOpen = iframeWindow.open;
          iframeWindow.open = function(url, target, features) {
            console.log('[Preload] iframe中拦截window.open:', url);
            if (url) {
              if (isInternalLink(url)) {
                notifyCreateNewTab(url);
              } else {
                openExternalLink(url);
              }
              return null;
            }
            return originalOpen.apply(this, arguments);
          };
        } catch (e) {
          console.warn('[Preload] 无法重写iframe的window.open:', e);
        }
        
        try {
          // 尝试访问文档并添加点击监听器
          const frameDoc = iframe.contentDocument || iframeWindow.document;
          if (frameDoc) {
            frameDoc.addEventListener('click', function(e) {
              const link = e.target.closest('a');
              if (link && (link.target === '_blank' || link.getAttribute('rel') === 'noopener' || e.ctrlKey || e.metaKey)) {
                const href = link.getAttribute('href');
                if (!href) return;
                
                console.log('[Preload] iframe中拦截链接点击:', href);
                e.preventDefault();
                e.stopPropagation();
                
                if (isInternalLink(href)) {
                  notifyCreateNewTab(href);
                } else {
                  openExternalLink(href);
                }
                return false;
              }
            }, true);
          }
        } catch (e) {
          console.warn('[Preload] 无法为iframe添加点击监听器:', e);
        }
      } catch (e) {
        console.error('[Preload] 访问iframe内容时出错:', e);
      }
    };
  } catch (err) {
    console.error('[Preload] 为iframe设置拦截器时出错:', err);
  }
}

// 打开外部链接
function openExternalLink(url) {
  try {
    console.log('[Preload] 通过默认浏览器打开外部链接:', url);
    
    // 通知主进程
    if (ipcRenderer) {
      ipcRenderer.send('open-external', url);
    }
    
    console.log('[Preload] 已通知打开外部链接:', url);
  } catch (err) {
    console.error('[Preload] 打开外部链接失败:', err);
  }
}

// 通知创建新标签（处理内部链接）
function notifyCreateNewTab(url) {
  try {
    // 检查是否为外部链接
    if (!isInternalLink(url)) {
      openExternalLink(url);
      return;
    }
    
    console.log('[Preload] 尝试在当前窗口加载内部链接:', url);
    
    // 通知主进程更新状态
    if (ipcRenderer) {
      ipcRenderer.send('create-new-tab', url);
    }
    
    // 尝试直接在当前窗口设置location
    try {
      // 确保是有效的内部链接
      if (url && (url.startsWith('http://') || url.startsWith('https://'))) {
        // 延迟执行，确保消息先发送
        setTimeout(() => {
          try {
            window.location.href = url;
          } catch (e) {
            console.warn('[Preload] 无法直接设置window.location:', e);
            // 作为备用，发送消息给渲染进程
            window.postMessage({ type: 'createNewTab', url: url }, '*');
          }
        }, 100);
      } else {
        // 发送消息给渲染进程
        window.postMessage({ type: 'createNewTab', url: url }, '*');
      }
    } catch (e) {
      console.warn('[Preload] 设置location时出错:', e);
      
      // 备用方案：使用postMessage
      window.postMessage({ type: 'createNewTab', url: url }, '*');
      
      // 尝试通知父窗口
      try {
        if (window !== window.top) {
          window.top.postMessage({ type: 'createNewTab', url: url }, '*');
        }
      } catch (e) {
        console.warn('[Preload] 无法通知顶层窗口:', e);
      }
    }
    
    console.log('[Preload] 已通知在当前窗口加载内部链接:', url);
  } catch (err) {
    console.error('[Preload] 通知加载内部链接时出错:', err);
  }
}

// 当完全加载时再次检查所有内容
window.addEventListener('load', function() {
  console.log('[Preload] 页面完全加载，最终检查');
  processFrames();
});

// 暴露方法给页面中的脚本
window.electronBridge = {
  createNewTab: function(url) {
    if (isInternalLink(url)) {
      notifyCreateNewTab(url);
    } else {
      openExternalLink(url);
    }
  },
  openExternal: function(url) {
    openExternalLink(url);
  }
};

console.log('[Preload] 脚本已加载');

// 判断是否为内部链接
function isInternalLink(url) {
  if (!url) return false;
  try {
    const urlObj = new URL(url);
    // 检查是否是允许在内部打开的域名
    return urlObj.hostname === 'www.liwenyan.site' || 
           urlObj.hostname.endsWith('.liwenyan.site');
  } catch (e) {
    // 如果无法解析URL，假设是外部链接
    return false;
  }
}
